home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 16 / CU Amiga Magazine's Super CD-ROM 16 (1997-10-16)(EMAP Images)(GB)[!][issue 1997-11].iso / CUCD / Graphics / Ghostscript / source / igcstr.c < prev    next >
C/C++ Source or Header  |  1996-08-03  |  10KB  |  363 lines
  1. /* Copyright (C) 1994, 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* igcstr.c */
  20. /* String GC routines for Ghostscript */
  21. #include "memory_.h"
  22. #include "ghost.h"
  23. #include "gsmdebug.h"
  24. #include "gsstruct.h"
  25. #include "iastate.h"
  26. #include "igcstr.h"
  27.  
  28. /* Forward references */
  29. private bool gc_mark_string(P4(const byte *, uint, bool, const chunk_t *));
  30.  
  31. /* (Un)mark the strings in a chunk. */
  32. void
  33. gc_strings_set_marks(chunk_t *cp, bool mark)
  34. {    if ( cp->smark != 0 )
  35.     { if_debug3('6', "[6]clearing string marks 0x%lx[%u] to %d\n",
  36.             (ulong)cp->smark, cp->smark_size, (int)mark);
  37.       memset(cp->smark, 0, cp->smark_size);
  38.       if ( mark )
  39.         gc_mark_string(cp->sbase, cp->climit - cp->sbase, true, cp);
  40.     }
  41. }
  42.  
  43. /* We mark strings a word at a time. */
  44. typedef string_mark_unit bword;
  45. #define bword_log2_bytes log2_sizeof_string_mark_unit
  46. #define bword_bytes (1 << bword_log2_bytes)
  47. #define bword_log2_bits (bword_log2_bytes + 3)
  48. #define bword_bits (1 << bword_log2_bits)
  49. #define bword_1s (~(bword)0)
  50. /* Compensate for byte order reversal if necessary. */
  51. #if arch_is_big_endian
  52. #  if bword_bytes == 2
  53. #    define bword_swap_bytes(m) m = (m << 8) | (m >> 8)
  54. #  else                /* bword_bytes == 4 */
  55. #    define bword_swap_bytes(m)\
  56.     m = (m << 24) | ((m & 0xff00) << 8) | ((m >> 8) & 0xff00) | (m >> 24)
  57. #  endif
  58. #else
  59. #  define bword_swap_bytes(m) DO_NOTHING
  60. #endif
  61.  
  62. /* (Un)mark a string in a known chunk.  Return true iff any new marks. */
  63. private bool
  64. gc_mark_string(const byte *ptr, uint size, bool set, const chunk_t *cp)
  65. {    uint offset = ptr - cp->sbase;
  66.     bword *bp = (bword *)(cp->smark + ((offset & -bword_bits) >> 3));
  67.     uint bn = offset & (bword_bits - 1);
  68.     bword m = bword_1s << bn;
  69.     uint left = size;
  70.     bword marks = 0;
  71.  
  72.     bword_swap_bytes(m);
  73.     if ( set )
  74.       {    if ( left + bn >= bword_bits )
  75.           {    marks |= ~*bp & m;
  76.             *bp |= m;
  77.             m = bword_1s, left -= bword_bits - bn, bp++;
  78.             while ( left >= bword_bits )
  79.               {    marks |= ~*bp;
  80.                 *bp = bword_1s;
  81.                 left -= bword_bits, bp++;
  82.               }
  83.           }
  84.         if ( left )
  85.           {    bword_swap_bytes(m);
  86.             m -= m << left;
  87.             bword_swap_bytes(m);
  88.             marks |= ~*bp & m;
  89.             *bp |= m;
  90.           }
  91.       }
  92.     else
  93.       {    if ( left + bn >= bword_bits )
  94.           {    *bp &= ~m;
  95.             m = bword_1s, left -= bword_bits - bn, bp++;
  96.             if ( left >= bword_bits * 5 )
  97.               {    memset(bp, 0, (left & -bword_bits) >> 3);
  98.                 bp += left >> bword_log2_bits;
  99.                 left &= bword_bits - 1;
  100.               }
  101.             else
  102.               while ( left >= bword_bits )
  103.                 {    *bp = 0;
  104.                 left -= bword_bits, bp++;
  105.                 }
  106.           }
  107.         if ( left )
  108.           {    bword_swap_bytes(m);
  109.             m -= m << left;
  110.             bword_swap_bytes(m);
  111.             *bp &= ~m;
  112.           }
  113.       }
  114.     return marks != 0;
  115. }
  116.  
  117. /* Mark a string.  Return true if any new marks. */
  118. bool
  119. gc_string_mark(const byte *ptr, uint size, bool set, gc_state_t *gcst)
  120. {    const chunk_t *cp;
  121.     bool marks;
  122.  
  123.     if ( size == 0 )
  124.       return false;
  125. #define dprintstr()\
  126.   dputc('('); fwrite(ptr, 1, min(size, 20), dstderr);\
  127.   dputs((size <= 20 ? ")" : "...)"))
  128.     if ( !(cp = gc_locate(ptr, gcst)) )    /* not in a chunk */
  129.       {
  130. #ifdef DEBUG
  131.         if ( gs_debug_c('5') )
  132.           {    dprintf2("[5]0x%lx[%u]", (ulong)ptr, size);
  133.             dprintstr();
  134.             dputs(" not in a chunk\n");
  135.           }
  136. #endif        
  137.         return false;
  138.       }
  139.     if ( cp->smark == 0 )        /* not marking strings */
  140.       return false;
  141. #ifdef DEBUG
  142.     if ( ptr < cp->ctop )
  143.       {    lprintf4("String pointer 0x%lx[%u] outside [0x%lx..0x%lx)\n",
  144.              (ulong)ptr, size, (ulong)cp->ctop, (ulong)cp->climit);
  145.         return false;
  146.       }
  147.     else if ( ptr + size > cp->climit )
  148.       {    /*
  149.          * If this is the bottommost string in a chunk that has
  150.          * an inner chunk, the string's starting address is both
  151.          * cp->ctop of the outer chunk and cp->climit of the inner;
  152.          * gc_locate may incorrectly attribute the string to the
  153.          * inner chunk because of this.  This doesn't affect
  154.          * marking or relocation, since the machinery for these
  155.          * is all associated with the outermost chunk,
  156.          * but it can cause the validity check to fail.
  157.          * Check for this case now.
  158.          */
  159.         const chunk_t *scp = cp;
  160.         while ( ptr == scp->climit && scp->outer != 0 )
  161.           scp = scp->outer;
  162.         if ( ptr + size > scp->climit )
  163.           {    lprintf4("String pointer 0x%lx[%u] outside [0x%lx..0x%lx)\n",
  164.                  (ulong)ptr, size,
  165.                  (ulong)scp->ctop, (ulong)scp->climit);
  166.             return false;
  167.           }
  168.       }
  169. #endif
  170.     marks = gc_mark_string(ptr, size, set, cp);
  171. #ifdef DEBUG
  172.     if ( gs_debug_c('5') )
  173.       {    dprintf4("[5]%s%smarked 0x%lx[%u]",
  174.              (marks ? "" : "already "), (set ? "" : "un"),
  175.              (ulong)ptr, size);
  176.         dprintstr();
  177.         dputc('\n');
  178.       }
  179. #endif
  180.     return marks;
  181. }
  182.  
  183. /* Clear the relocation for strings. */
  184. /* This requires setting the marks. */
  185. void
  186. gc_strings_clear_reloc(chunk_t *cp)
  187. {    if ( cp->sreloc != 0 )
  188.       { gc_strings_set_marks(cp, true);
  189.         if_debug1('6', "[6]clearing string reloc 0x%lx\n",
  190.               (ulong)cp->sreloc);
  191.         gc_strings_set_reloc(cp);
  192.       }
  193. }
  194.  
  195. /* Count the 0-bits in a byte. */
  196. private const byte count_zero_bits_table[256] = {
  197. #define o4(n) n,n-1,n-1,n-2
  198. #define o16(n) o4(n),o4(n-1),o4(n-1),o4(n-2)
  199. #define o64(n) o16(n),o16(n-1),o16(n-1),o16(n-2)
  200.     o64(8), o64(7), o64(7), o64(6)
  201. };
  202. #define byte_count_zero_bits(byt)\
  203.   (uint)(count_zero_bits_table[byt])
  204. #define byte_count_one_bits(byt)\
  205.   (uint)(8 - count_zero_bits_table[byt])
  206.  
  207. /* Set the relocation for the strings in a chunk. */
  208. /* The sreloc table stores the relocated offset from climit for */
  209. /* the beginning of each block of string_data_quantum characters. */
  210. void
  211. gc_strings_set_reloc(chunk_t *cp)
  212. {    if ( cp->sreloc != 0 && cp->smark != 0 )
  213.     {    byte *bot = cp->ctop;
  214.         byte *top = cp->climit;
  215.         uint count =
  216.           (top - bot + (string_data_quantum - 1)) >>
  217.             log2_string_data_quantum;
  218.         string_reloc_offset *relp =
  219.           cp->sreloc +
  220.             (cp->smark_size >> (log2_string_data_quantum - 3));
  221.         register byte *bitp = cp->smark + cp->smark_size;
  222.         register string_reloc_offset reloc = 0;
  223.  
  224.         while ( count-- )
  225.         {    bitp -= string_data_quantum / 8;
  226.             reloc += string_data_quantum -
  227.               byte_count_zero_bits(bitp[0]);
  228.             reloc -= byte_count_zero_bits(bitp[1]);
  229.             reloc -= byte_count_zero_bits(bitp[2]);
  230.             reloc -= byte_count_zero_bits(bitp[3]);
  231. #if log2_string_data_quantum > 5
  232.             reloc -= byte_count_zero_bits(bitp[4]);
  233.             reloc -= byte_count_zero_bits(bitp[5]);
  234.             reloc -= byte_count_zero_bits(bitp[6]);
  235.             reloc -= byte_count_zero_bits(bitp[7]);
  236. #endif
  237.             *--relp = reloc;
  238.         }
  239.     }
  240.     cp->sdest = cp->climit;
  241. }
  242.  
  243. /* Relocate a string pointer. */
  244. void
  245. gs_reloc_string(gs_string *sptr, gc_state_t *gcst)
  246. {    byte *ptr;
  247.     const chunk_t *cp;
  248.     uint offset;
  249.     uint reloc;
  250.     const byte *bitp;
  251.     byte byt;
  252.  
  253.     if ( sptr->size == 0 )
  254.       {    sptr->data = 0;
  255.         return;
  256.       }
  257.     ptr = sptr->data;
  258.     if ( !(cp = gc_locate(ptr, gcst)) )    /* not in a chunk */
  259.       return;
  260.     if ( cp->sreloc == 0 || cp->smark == 0 ) /* not marking strings */
  261.       return;
  262.     offset = ptr - cp->sbase;
  263.     reloc = cp->sreloc[offset >> log2_string_data_quantum];
  264.     bitp = &cp->smark[offset >> 3];
  265.     switch ( offset & (string_data_quantum - 8) )
  266.     {
  267. #if log2_string_data_quantum > 5
  268.     case 56: reloc -= byte_count_one_bits(bitp[-7]);
  269.     case 48: reloc -= byte_count_one_bits(bitp[-6]);
  270.     case 40: reloc -= byte_count_one_bits(bitp[-5]);
  271.     case 32: reloc -= byte_count_one_bits(bitp[-4]);
  272. #endif
  273.     case 24: reloc -= byte_count_one_bits(bitp[-3]);
  274.     case 16: reloc -= byte_count_one_bits(bitp[-2]);
  275.     case 8: reloc -= byte_count_one_bits(bitp[-1]);
  276.     }
  277.     byt = *bitp & (0xff >> (8 - (offset & 7)));
  278.     reloc -= byte_count_one_bits(byt);
  279.     if_debug2('5', "[5]relocate string 0x%lx to 0x%lx\n",
  280.           (ulong)ptr, (ulong)(cp->sdest - reloc));
  281.     sptr->data = cp->sdest - reloc;
  282. }
  283. void
  284. gs_reloc_const_string(gs_const_string *sptr, gc_state_t *gcst)
  285. {    /* We assume the representation of byte * and const byte * is */
  286.     /* the same.... */
  287.     gs_reloc_string((gs_string *)sptr, gcst);
  288. }
  289.  
  290. /* Compact the strings in a chunk. */
  291. void
  292. gc_strings_compact(chunk_t *cp)
  293. {    if ( cp->smark != 0 )
  294.     {    byte *hi = cp->climit;
  295.         byte *lo = cp->ctop;
  296.         register const byte *from = hi;
  297.         register byte *to = hi;
  298.         register const byte *bp = cp->smark + cp->smark_size;
  299.  
  300. #ifdef DEBUG
  301.         if ( gs_debug_c('4') || gs_debug_c('5') )
  302.           { byte *base = cp->sbase;
  303.             uint i = (lo - base) & -string_data_quantum;
  304.             uint n = round_up(hi - base, string_data_quantum);
  305. #define R 16
  306.             for ( ; i < n; i += R )
  307.               { uint j;
  308.  
  309.             dprintf1("[4]0x%lx: ", (ulong)(base + i));
  310.             for ( j = i; j < i + R; j++ )
  311.               { byte ch = base[j];
  312.  
  313.                 if ( ch <= 31 )
  314.                   { dputc('^'); dputc(ch + 0100); }
  315.                 else
  316.                   dputc(ch);
  317.               }
  318.             dputc(' ');
  319.             for ( j = i; j < i + R; j++ )
  320.               dputc((cp->smark[j >> 3] & (1 << (j & 7)) ?
  321.                  '+' : '.'));
  322. #undef R
  323.             if ( !(i & (string_data_quantum - 1)) )
  324.               dprintf1(" %u", cp->sreloc[i >> log2_string_data_quantum]);
  325.             dputc('\n');
  326.               }
  327.           }
  328. #endif
  329.         while ( from > lo )
  330.           { register byte b = *--bp;
  331.  
  332.             from -= 8;
  333.             switch ( b )
  334.               {
  335.               case 0xff:
  336.             to -= 8;
  337.             if ( to != from )
  338.               { to[7] = from[7]; to[6] = from[6];
  339.                 to[5] = from[5]; to[4] = from[4];
  340.                 to[3] = from[3]; to[2] = from[2];
  341.                 to[1] = from[1]; to[0] = from[0];
  342.               }
  343.             break;
  344.               default:
  345.             if ( b & 0x80 ) *--to = from[7];
  346.             if ( b & 0x40 ) *--to = from[6];
  347.             if ( b & 0x20 ) *--to = from[5];
  348.             if ( b & 0x10 ) *--to = from[4];
  349.             if ( b & 8 ) *--to = from[3];
  350.             if ( b & 4 ) *--to = from[2];
  351.             if ( b & 2 ) *--to = from[1];
  352.             if ( b & 1 ) *--to = from[0];
  353.             /* falls through */
  354.               case 0:
  355.             ;
  356.               }
  357.           }
  358.         gs_alloc_fill(cp->ctop, gs_alloc_fill_collected,
  359.                   to - cp->ctop);
  360.         cp->ctop = to;
  361.     }
  362. }
  363.